<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"><html xmlns="http://www.w3.org/1999/xhtml"><head><link rel="stylesheet" type="text/css" href="style.css" /><script type="text/javascript" src="highlight.js"></script></head><body><pre><span class="hs-pragma">{-# LANGUAGE Trustworthy #-}</span><span>
</span><span id="line-2"></span><span class="hs-pragma">{-# LANGUAGE CPP, NoImplicitPrelude, ScopedTypeVariables, BangPatterns #-}</span><span>
</span><span id="line-3"></span><span>
</span><span id="line-4"></span><span class="hs-comment">-----------------------------------------------------------------------------</span><span>
</span><span id="line-5"></span><span class="hs-comment">-- |</span><span>
</span><span id="line-6"></span><span class="hs-comment">-- Module      :  Foreign.Storable</span><span>
</span><span id="line-7"></span><span class="hs-comment">-- Copyright   :  (c) The FFI task force 2001</span><span>
</span><span id="line-8"></span><span class="hs-comment">-- License     :  see libraries/base/LICENSE</span><span>
</span><span id="line-9"></span><span class="hs-comment">-- </span><span>
</span><span id="line-10"></span><span class="hs-comment">-- Maintainer  :  ffi@haskell.org</span><span>
</span><span id="line-11"></span><span class="hs-comment">-- Stability   :  provisional</span><span>
</span><span id="line-12"></span><span class="hs-comment">-- Portability :  portable</span><span>
</span><span id="line-13"></span><span class="hs-comment">--</span><span>
</span><span id="line-14"></span><span class="hs-comment">-- The module &quot;Foreign.Storable&quot; provides most elementary support for</span><span>
</span><span id="line-15"></span><span class="hs-comment">-- marshalling and is part of the language-independent portion of the</span><span>
</span><span id="line-16"></span><span class="hs-comment">-- Foreign Function Interface (FFI), and will normally be imported via</span><span>
</span><span id="line-17"></span><span class="hs-comment">-- the &quot;Foreign&quot; module.</span><span>
</span><span id="line-18"></span><span class="hs-comment">--</span><span>
</span><span id="line-19"></span><span class="hs-comment">-----------------------------------------------------------------------------</span><span>
</span><span id="line-20"></span><span>
</span><span id="line-21"></span><span class="hs-keyword">module</span><span> </span><span class="hs-identifier">Foreign.Storable</span><span>
</span><span id="line-22"></span><span>        </span><span class="hs-special">(</span><span> </span><span class="annot"><a href="Foreign.Storable.html#Storable"><span class="hs-identifier">Storable</span></a></span><span class="hs-special">(</span><span>
</span><span id="line-23"></span><span>             </span><span class="annot"><a href="Foreign.Storable.html#sizeOf"><span class="hs-identifier">sizeOf</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-24"></span><span>             </span><span class="annot"><a href="Foreign.Storable.html#alignment"><span class="hs-identifier">alignment</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-25"></span><span>             </span><span class="annot"><a href="Foreign.Storable.html#peekElemOff"><span class="hs-identifier">peekElemOff</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-26"></span><span>             </span><span class="annot"><a href="Foreign.Storable.html#pokeElemOff"><span class="hs-identifier">pokeElemOff</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-27"></span><span>             </span><span class="annot"><a href="Foreign.Storable.html#peekByteOff"><span class="hs-identifier">peekByteOff</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-28"></span><span>             </span><span class="annot"><a href="Foreign.Storable.html#pokeByteOff"><span class="hs-identifier">pokeByteOff</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-29"></span><span>             </span><span class="annot"><a href="Foreign.Storable.html#peek"><span class="hs-identifier">peek</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-30"></span><span>             </span><span class="annot"><a href="Foreign.Storable.html#poke"><span class="hs-identifier">poke</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-31"></span><span>        </span><span class="hs-special">)</span><span> </span><span class="hs-keyword">where</span><span class="hs-cpp">


#include &quot;MachDeps.h&quot;
</span><span class="hs-cpp">#include &quot;HsBaseConfig.h&quot;
</span><span>
</span><span id="line-37"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="GHC.Storable.html"><span class="hs-identifier">GHC.Storable</span></a></span><span>
</span><span id="line-38"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="GHC.Stable.html"><span class="hs-identifier">GHC.Stable</span></a></span><span>       </span><span class="hs-special">(</span><span> </span><span class="annot"><a href="GHC.Stable.html#StablePtr"><span class="hs-identifier">StablePtr</span></a></span><span> </span><span class="hs-special">)</span><span>
</span><span id="line-39"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="GHC.Num.html"><span class="hs-identifier">GHC.Num</span></a></span><span>
</span><span id="line-40"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="GHC.Int.html"><span class="hs-identifier">GHC.Int</span></a></span><span>
</span><span id="line-41"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="GHC.Word.html"><span class="hs-identifier">GHC.Word</span></a></span><span>
</span><span id="line-42"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="GHC.Ptr.html"><span class="hs-identifier">GHC.Ptr</span></a></span><span>
</span><span id="line-43"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="GHC.Base.html"><span class="hs-identifier">GHC.Base</span></a></span><span>
</span><span id="line-44"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="GHC.Fingerprint.Type.html"><span class="hs-identifier">GHC.Fingerprint.Type</span></a></span><span>
</span><span id="line-45"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="Data.Bits.html"><span class="hs-identifier">Data.Bits</span></a></span><span>
</span><span id="line-46"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="GHC.Real.html"><span class="hs-identifier">GHC.Real</span></a></span><span>
</span><span id="line-47"></span><span>
</span><span id="line-48"></span><span class="hs-comment">{- |
The member functions of this class facilitate writing values of
primitive types to raw memory (which may have been allocated with the
above mentioned routines) and reading values from blocks of raw
memory.  The class, furthermore, includes support for computing the
storage requirements and alignment restrictions of storable types.

Memory addresses are represented as values of type @'Ptr' a@, for some
@a@ which is an instance of class 'Storable'.  The type argument to
'Ptr' helps provide some valuable type safety in FFI code (you can\'t
mix pointers of different types without an explicit cast), while
helping the Haskell type system figure out which marshalling method is
needed for a given pointer.

All marshalling between Haskell and a foreign language ultimately
boils down to translating Haskell data structures into the binary
representation of a corresponding data structure of the foreign
language and vice versa.  To code this marshalling in Haskell, it is
necessary to manipulate primitive data types stored in unstructured
memory blocks.  The class 'Storable' facilitates this manipulation on
all types for which it is instantiated, which are the standard basic
types of Haskell, the fixed size @Int@ types ('Int8', 'Int16',
'Int32', 'Int64'), the fixed size @Word@ types ('Word8', 'Word16',
'Word32', 'Word64'), 'StablePtr', all types from &quot;Foreign.C.Types&quot;,
as well as 'Ptr'.
-}</span><span>
</span><span id="line-74"></span><span>
</span><span id="line-75"></span><span class="hs-keyword">class</span><span> </span><span id="Storable"><span class="annot"><a href="Foreign.Storable.html#Storable"><span class="hs-identifier hs-var">Storable</span></a></span></span><span> </span><span id="local-6989586621679508319"><span class="annot"><a href="#local-6989586621679508319"><span class="hs-identifier hs-type">a</span></a></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-76"></span><span>   </span><span class="hs-pragma">{-# MINIMAL</span><span> </span><span class="annot"><a href="Foreign.Storable.html#sizeOf"><span class="hs-pragma hs-type">sizeOf</span></a></span><span class="hs-pragma">,</span><span> </span><span class="annot"><a href="Foreign.Storable.html#alignment"><span class="hs-pragma hs-type">alignment</span></a></span><span class="hs-pragma">,</span><span>
</span><span id="line-77"></span><span>               </span><span class="hs-pragma">(</span><span class="annot"><a href="Foreign.Storable.html#peek"><span class="hs-pragma hs-type">peek</span></a></span><span> </span><span class="hs-pragma">|</span><span> </span><span class="annot"><a href="Foreign.Storable.html#peekElemOff"><span class="hs-pragma hs-type">peekElemOff</span></a></span><span> </span><span class="hs-pragma">|</span><span> </span><span class="annot"><a href="Foreign.Storable.html#peekByteOff"><span class="hs-pragma hs-type">peekByteOff</span></a></span><span class="hs-pragma">)</span><span class="hs-pragma">,</span><span>
</span><span id="line-78"></span><span>               </span><span class="hs-pragma">(</span><span class="annot"><a href="Foreign.Storable.html#poke"><span class="hs-pragma hs-type">poke</span></a></span><span> </span><span class="hs-pragma">|</span><span> </span><span class="annot"><a href="Foreign.Storable.html#pokeElemOff"><span class="hs-pragma hs-type">pokeElemOff</span></a></span><span> </span><span class="hs-pragma">|</span><span> </span><span class="annot"><a href="Foreign.Storable.html#pokeByteOff"><span class="hs-pragma hs-type">pokeByteOff</span></a></span><span class="hs-pragma">)</span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-79"></span><span>
</span><span id="line-80"></span><span>   </span><span id="sizeOf"><span class="annot"><a href="Foreign.Storable.html#sizeOf"><span class="hs-identifier hs-type">sizeOf</span></a></span></span><span>      </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="#local-6989586621679508319"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#Int"><span class="hs-identifier hs-type">Int</span></a></span><span>
</span><span id="line-81"></span><span>   </span><span class="hs-comment">-- ^ Computes the storage requirements (in bytes) of the argument.</span><span>
</span><span id="line-82"></span><span>   </span><span class="hs-comment">-- The value of the argument is not used.</span><span>
</span><span id="line-83"></span><span>
</span><span id="line-84"></span><span>   </span><span id="alignment"><span class="annot"><a href="Foreign.Storable.html#alignment"><span class="hs-identifier hs-type">alignment</span></a></span></span><span>   </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="#local-6989586621679508319"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#Int"><span class="hs-identifier hs-type">Int</span></a></span><span>
</span><span id="line-85"></span><span>   </span><span class="hs-comment">-- ^ Computes the alignment constraint of the argument.  An</span><span>
</span><span id="line-86"></span><span>   </span><span class="hs-comment">-- alignment constraint @x@ is fulfilled by any address divisible</span><span>
</span><span id="line-87"></span><span>   </span><span class="hs-comment">-- by @x@.  The value of the argument is not used.</span><span>
</span><span id="line-88"></span><span>
</span><span id="line-89"></span><span>   </span><span id="peekElemOff"><span class="annot"><a href="Foreign.Storable.html#peekElemOff"><span class="hs-identifier hs-type">peekElemOff</span></a></span></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.Ptr.html#Ptr"><span class="hs-identifier hs-type">Ptr</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679508319"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#Int"><span class="hs-identifier hs-type">Int</span></a></span><span>      </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#IO"><span class="hs-identifier hs-type">IO</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679508319"><span class="hs-identifier hs-type">a</span></a></span><span>
</span><span id="line-90"></span><span>   </span><span class="hs-comment">-- ^       Read a value from a memory area regarded as an array</span><span>
</span><span id="line-91"></span><span>   </span><span class="hs-comment">--         of values of the same kind.  The first argument specifies</span><span>
</span><span id="line-92"></span><span>   </span><span class="hs-comment">--         the start address of the array and the second the index into</span><span>
</span><span id="line-93"></span><span>   </span><span class="hs-comment">--         the array (the first element of the array has index</span><span>
</span><span id="line-94"></span><span>   </span><span class="hs-comment">--         @0@).  The following equality holds,</span><span>
</span><span id="line-95"></span><span>   </span><span class="hs-comment">-- </span><span>
</span><span id="line-96"></span><span>   </span><span class="hs-comment">-- &gt; peekElemOff addr idx = IOExts.fixIO $ \result -&gt;</span><span>
</span><span id="line-97"></span><span>   </span><span class="hs-comment">-- &gt;   peek (addr `plusPtr` (idx * sizeOf result))</span><span>
</span><span id="line-98"></span><span>   </span><span class="hs-comment">--</span><span>
</span><span id="line-99"></span><span>   </span><span class="hs-comment">--         Note that this is only a specification, not</span><span>
</span><span id="line-100"></span><span>   </span><span class="hs-comment">--         necessarily the concrete implementation of the</span><span>
</span><span id="line-101"></span><span>   </span><span class="hs-comment">--         function.</span><span>
</span><span id="line-102"></span><span>
</span><span id="line-103"></span><span>   </span><span id="pokeElemOff"><span class="annot"><a href="Foreign.Storable.html#pokeElemOff"><span class="hs-identifier hs-type">pokeElemOff</span></a></span></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.Ptr.html#Ptr"><span class="hs-identifier hs-type">Ptr</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679508319"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#Int"><span class="hs-identifier hs-type">Int</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679508319"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#IO"><span class="hs-identifier hs-type">IO</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span><span>
</span><span id="line-104"></span><span>   </span><span class="hs-comment">-- ^       Write a value to a memory area regarded as an array of</span><span>
</span><span id="line-105"></span><span>   </span><span class="hs-comment">--         values of the same kind.  The following equality holds:</span><span>
</span><span id="line-106"></span><span>   </span><span class="hs-comment">-- </span><span>
</span><span id="line-107"></span><span>   </span><span class="hs-comment">-- &gt; pokeElemOff addr idx x = </span><span>
</span><span id="line-108"></span><span>   </span><span class="hs-comment">-- &gt;   poke (addr `plusPtr` (idx * sizeOf x)) x</span><span>
</span><span id="line-109"></span><span>
</span><span id="line-110"></span><span>   </span><span id="local-6989586621679508315"><span id="peekByteOff"><span class="annot"><a href="Foreign.Storable.html#peekByteOff"><span class="hs-identifier hs-type">peekByteOff</span></a></span></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.Ptr.html#Ptr"><span class="hs-identifier hs-type">Ptr</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679508315"><span class="hs-identifier hs-type">b</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#Int"><span class="hs-identifier hs-type">Int</span></a></span><span>      </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#IO"><span class="hs-identifier hs-type">IO</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679508319"><span class="hs-identifier hs-type">a</span></a></span></span><span>
</span><span id="line-111"></span><span>   </span><span class="hs-comment">-- ^       Read a value from a memory location given by a base</span><span>
</span><span id="line-112"></span><span>   </span><span class="hs-comment">--         address and offset.  The following equality holds:</span><span>
</span><span id="line-113"></span><span>   </span><span class="hs-comment">--</span><span>
</span><span id="line-114"></span><span>   </span><span class="hs-comment">-- &gt; peekByteOff addr off = peek (addr `plusPtr` off)</span><span>
</span><span id="line-115"></span><span>
</span><span id="line-116"></span><span>   </span><span id="local-6989586621679508313"><span id="pokeByteOff"><span class="annot"><a href="Foreign.Storable.html#pokeByteOff"><span class="hs-identifier hs-type">pokeByteOff</span></a></span></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.Ptr.html#Ptr"><span class="hs-identifier hs-type">Ptr</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679508313"><span class="hs-identifier hs-type">b</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#Int"><span class="hs-identifier hs-type">Int</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679508319"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#IO"><span class="hs-identifier hs-type">IO</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span></span><span>
</span><span id="line-117"></span><span>   </span><span class="hs-comment">-- ^       Write a value to a memory location given by a base</span><span>
</span><span id="line-118"></span><span>   </span><span class="hs-comment">--         address and offset.  The following equality holds:</span><span>
</span><span id="line-119"></span><span>   </span><span class="hs-comment">--</span><span>
</span><span id="line-120"></span><span>   </span><span class="hs-comment">-- &gt; pokeByteOff addr off x = poke (addr `plusPtr` off) x</span><span>
</span><span id="line-121"></span><span>  </span><span>
</span><span id="line-122"></span><span>   </span><span id="peek"><span class="annot"><a href="Foreign.Storable.html#peek"><span class="hs-identifier hs-type">peek</span></a></span></span><span>        </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.Ptr.html#Ptr"><span class="hs-identifier hs-type">Ptr</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679508319"><span class="hs-identifier hs-type">a</span></a></span><span>      </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#IO"><span class="hs-identifier hs-type">IO</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679508319"><span class="hs-identifier hs-type">a</span></a></span><span>
</span><span id="line-123"></span><span>   </span><span class="hs-comment">-- ^ Read a value from the given memory location.</span><span>
</span><span id="line-124"></span><span>   </span><span class="hs-comment">--</span><span>
</span><span id="line-125"></span><span>   </span><span class="hs-comment">--  Note that the peek and poke functions might require properly</span><span>
</span><span id="line-126"></span><span>   </span><span class="hs-comment">--  aligned addresses to function correctly.  This is architecture</span><span>
</span><span id="line-127"></span><span>   </span><span class="hs-comment">--  dependent; thus, portable code should ensure that when peeking or</span><span>
</span><span id="line-128"></span><span>   </span><span class="hs-comment">--  poking values of some type @a@, the alignment</span><span>
</span><span id="line-129"></span><span>   </span><span class="hs-comment">--  constraint for @a@, as given by the function</span><span>
</span><span id="line-130"></span><span>   </span><span class="hs-comment">--  'alignment' is fulfilled.</span><span>
</span><span id="line-131"></span><span>
</span><span id="line-132"></span><span>   </span><span id="poke"><span class="annot"><a href="Foreign.Storable.html#poke"><span class="hs-identifier hs-type">poke</span></a></span></span><span>        </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.Ptr.html#Ptr"><span class="hs-identifier hs-type">Ptr</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679508319"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679508319"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#IO"><span class="hs-identifier hs-type">IO</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span><span>
</span><span id="line-133"></span><span>   </span><span class="hs-comment">-- ^ Write the given value to the given memory location.  Alignment</span><span>
</span><span id="line-134"></span><span>   </span><span class="hs-comment">-- restrictions might apply; see 'peek'.</span><span>
</span><span id="line-135"></span><span> </span><span>
</span><span id="line-136"></span><span>   </span><span class="hs-comment">-- circular default instances</span><span>
</span><span id="line-137"></span><span>   </span><span id="local-6989586621679508141"><span class="annot"><a href="Foreign.Storable.html#peekElemOff"><span class="hs-identifier hs-var hs-var">peekElemOff</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">a -&gt; Ptr a -&gt; Int -&gt; IO a
</span><a href="#local-6989586621679508135"><span class="hs-identifier hs-var">peekElemOff_</span></a></span><span> </span><span class="annot"><span class="annottext">a
forall a. HasCallStack =&gt; a
</span><a href="GHC.Err.html#undefined"><span class="hs-identifier hs-var">undefined</span></a></span><span>
</span><span id="line-138"></span><span>      </span><span class="hs-keyword">where</span><span> </span><span class="annot"><a href="#local-6989586621679508135"><span class="hs-identifier hs-type">peekElemOff_</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="#local-6989586621679508319"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Ptr.html#Ptr"><span class="hs-identifier hs-type">Ptr</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679508319"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#Int"><span class="hs-identifier hs-type">Int</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#IO"><span class="hs-identifier hs-type">IO</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679508319"><span class="hs-identifier hs-type">a</span></a></span><span>
</span><span id="line-139"></span><span>            </span><span id="local-6989586621679508135"><span class="annot"><span class="annottext">peekElemOff_ :: a -&gt; Ptr a -&gt; Int -&gt; IO a
</span><a href="#local-6989586621679508135"><span class="hs-identifier hs-var hs-var">peekElemOff_</span></a></span></span><span> </span><span id="local-6989586621679508133"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679508133"><span class="hs-identifier hs-var">undef</span></a></span></span><span> </span><span id="local-6989586621679508132"><span class="annot"><span class="annottext">Ptr a
</span><a href="#local-6989586621679508132"><span class="hs-identifier hs-var">ptr</span></a></span></span><span> </span><span id="local-6989586621679508131"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679508131"><span class="hs-identifier hs-var">off</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Ptr a -&gt; Int -&gt; IO a
forall a b. Storable a =&gt; Ptr b -&gt; Int -&gt; IO a
</span><a href="Foreign.Storable.html#peekByteOff"><span class="hs-identifier hs-var">peekByteOff</span></a></span><span> </span><span class="annot"><span class="annottext">Ptr a
</span><a href="#local-6989586621679508132"><span class="hs-identifier hs-var">ptr</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679508131"><span class="hs-identifier hs-var">off</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Int
forall a. Num a =&gt; a -&gt; a -&gt; a
</span><a href="GHC.Num.html#%2A"><span class="hs-operator hs-var">*</span></a></span><span> </span><span class="annot"><span class="annottext">a -&gt; Int
forall a. Storable a =&gt; a -&gt; Int
</span><a href="Foreign.Storable.html#sizeOf"><span class="hs-identifier hs-var">sizeOf</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679508133"><span class="hs-identifier hs-var">undef</span></a></span><span class="hs-special">)</span></span><span>
</span><span id="line-140"></span><span>   </span><span id="local-6989586621679508129"><span class="annot"><a href="Foreign.Storable.html#pokeElemOff"><span class="hs-identifier hs-var hs-var">pokeElemOff</span></a></span><span> </span><span id="local-6989586621679508125"><span class="annot"><span class="annottext">Ptr a
</span><a href="#local-6989586621679508125"><span class="hs-identifier hs-var">ptr</span></a></span></span><span> </span><span id="local-6989586621679508124"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679508124"><span class="hs-identifier hs-var">off</span></a></span></span><span> </span><span id="local-6989586621679508123"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679508123"><span class="hs-identifier hs-var">val</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Ptr a -&gt; Int -&gt; a -&gt; IO ()
forall a b. Storable a =&gt; Ptr b -&gt; Int -&gt; a -&gt; IO ()
</span><a href="Foreign.Storable.html#pokeByteOff"><span class="hs-identifier hs-var">pokeByteOff</span></a></span><span> </span><span class="annot"><span class="annottext">Ptr a
</span><a href="#local-6989586621679508125"><span class="hs-identifier hs-var">ptr</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679508124"><span class="hs-identifier hs-var">off</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Int
forall a. Num a =&gt; a -&gt; a -&gt; a
</span><a href="GHC.Num.html#%2A"><span class="hs-operator hs-var">*</span></a></span><span> </span><span class="annot"><span class="annottext">a -&gt; Int
forall a. Storable a =&gt; a -&gt; Int
</span><a href="Foreign.Storable.html#sizeOf"><span class="hs-identifier hs-var">sizeOf</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679508123"><span class="hs-identifier hs-var">val</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679508123"><span class="hs-identifier hs-var">val</span></a></span></span><span>
</span><span id="line-141"></span><span>
</span><span id="line-142"></span><span>   </span><span id="local-6989586621679508122"><span class="annot"><a href="Foreign.Storable.html#peekByteOff"><span class="hs-identifier hs-var hs-var">peekByteOff</span></a></span><span> </span><span id="local-6989586621679508120"><span class="annot"><span class="annottext">Ptr b
</span><a href="#local-6989586621679508120"><span class="hs-identifier hs-var">ptr</span></a></span></span><span> </span><span id="local-6989586621679508119"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679508119"><span class="hs-identifier hs-var">off</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Ptr a -&gt; IO a
forall a. Storable a =&gt; Ptr a -&gt; IO a
</span><a href="Foreign.Storable.html#peek"><span class="hs-identifier hs-var">peek</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Ptr b
</span><a href="#local-6989586621679508120"><span class="hs-identifier hs-var">ptr</span></a></span><span> </span><span class="annot"><span class="annottext">Ptr b -&gt; Int -&gt; Ptr a
forall a b. Ptr a -&gt; Int -&gt; Ptr b
</span><a href="GHC.Ptr.html#plusPtr"><span class="hs-operator hs-var">`plusPtr`</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679508119"><span class="hs-identifier hs-var">off</span></a></span><span class="hs-special">)</span></span><span>
</span><span id="line-143"></span><span>   </span><span id="local-6989586621679508117"><span class="annot"><a href="Foreign.Storable.html#pokeByteOff"><span class="hs-identifier hs-var hs-var">pokeByteOff</span></a></span><span> </span><span id="local-6989586621679508115"><span class="annot"><span class="annottext">Ptr b
</span><a href="#local-6989586621679508115"><span class="hs-identifier hs-var">ptr</span></a></span></span><span> </span><span id="local-6989586621679508114"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679508114"><span class="hs-identifier hs-var">off</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Ptr a -&gt; a -&gt; IO ()
forall a. Storable a =&gt; Ptr a -&gt; a -&gt; IO ()
</span><a href="Foreign.Storable.html#poke"><span class="hs-identifier hs-var">poke</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Ptr b
</span><a href="#local-6989586621679508115"><span class="hs-identifier hs-var">ptr</span></a></span><span> </span><span class="annot"><span class="annottext">Ptr b -&gt; Int -&gt; Ptr a
forall a b. Ptr a -&gt; Int -&gt; Ptr b
</span><a href="GHC.Ptr.html#plusPtr"><span class="hs-operator hs-var">`plusPtr`</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679508114"><span class="hs-identifier hs-var">off</span></a></span><span class="hs-special">)</span></span><span>
</span><span id="line-144"></span><span>
</span><span id="line-145"></span><span>   </span><span id="local-6989586621679508113"><span class="annot"><a href="Foreign.Storable.html#peek"><span class="hs-identifier hs-var hs-var">peek</span></a></span><span> </span><span id="local-6989586621679508111"><span class="annot"><span class="annottext">Ptr a
</span><a href="#local-6989586621679508111"><span class="hs-identifier hs-var">ptr</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Ptr a -&gt; Int -&gt; IO a
forall a. Storable a =&gt; Ptr a -&gt; Int -&gt; IO a
</span><a href="Foreign.Storable.html#peekElemOff"><span class="hs-identifier hs-var">peekElemOff</span></a></span><span> </span><span class="annot"><span class="annottext">Ptr a
</span><a href="#local-6989586621679508111"><span class="hs-identifier hs-var">ptr</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">0</span></span></span><span>
</span><span id="line-146"></span><span>   </span><span id="local-6989586621679508110"><span class="annot"><a href="Foreign.Storable.html#poke"><span class="hs-identifier hs-var hs-var">poke</span></a></span><span> </span><span id="local-6989586621679508108"><span class="annot"><span class="annottext">Ptr a
</span><a href="#local-6989586621679508108"><span class="hs-identifier hs-var">ptr</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Ptr a -&gt; Int -&gt; a -&gt; IO ()
forall a. Storable a =&gt; Ptr a -&gt; Int -&gt; a -&gt; IO ()
</span><a href="Foreign.Storable.html#pokeElemOff"><span class="hs-identifier hs-var">pokeElemOff</span></a></span><span> </span><span class="annot"><span class="annottext">Ptr a
</span><a href="#local-6989586621679508108"><span class="hs-identifier hs-var">ptr</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">0</span></span></span><span>
</span><span id="line-147"></span><span>
</span><span id="line-148"></span><span class="hs-comment">-- | @since 4.9.0.0</span><span>
</span><span id="line-149"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679508098"><span id="local-6989586621679508100"><span id="local-6989586621679508102"><span id="local-6989586621679508104"><span class="annot"><a href="Foreign.Storable.html#Storable"><span class="hs-identifier hs-type">Storable</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span></span></span></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-150"></span><span>  </span><span id="local-6989586621679508094"><span class="annot"><span class="annottext">sizeOf :: () -&gt; Int
</span><a href="#local-6989586621679508094"><span class="hs-identifier hs-var hs-var hs-var hs-var">sizeOf</span></a></span></span><span> </span><span class="annot"><span class="annottext">()
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">0</span></span><span>
</span><span id="line-151"></span><span>  </span><span id="local-6989586621679508093"><span class="annot"><span class="annottext">alignment :: () -&gt; Int
</span><a href="#local-6989586621679508093"><span class="hs-identifier hs-var hs-var hs-var hs-var">alignment</span></a></span></span><span> </span><span class="annot"><span class="annottext">()
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">1</span></span><span>
</span><span id="line-152"></span><span>  </span><span id="local-6989586621679508091"><span class="annot"><span class="annottext">peek :: Ptr () -&gt; IO ()
</span><a href="#local-6989586621679508091"><span class="hs-identifier hs-var hs-var hs-var hs-var">peek</span></a></span></span><span> </span><span class="annot"><span class="annottext">Ptr ()
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">() -&gt; IO ()
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span><span>
</span><span id="line-153"></span><span>  </span><span id="local-6989586621679508089"><span class="annot"><span class="annottext">poke :: Ptr () -&gt; () -&gt; IO ()
</span><a href="#local-6989586621679508089"><span class="hs-identifier hs-var hs-var hs-var hs-var">poke</span></a></span></span><span> </span><span class="annot"><span class="annottext">Ptr ()
</span><span class="hs-identifier">_</span></span><span> </span><span class="annot"><span class="annottext">()
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">() -&gt; IO ()
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span><span>
</span><span id="line-154"></span><span>
</span><span id="line-155"></span><span class="hs-comment">-- System-dependent, but rather obvious instances</span><span>
</span><span id="line-156"></span><span>
</span><span id="line-157"></span><span class="hs-comment">-- | @since 2.01</span><span>
</span><span id="line-158"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679508077"><span id="local-6989586621679508079"><span id="local-6989586621679508081"><span id="local-6989586621679508083"><span class="annot"><a href="Foreign.Storable.html#Storable"><span class="hs-identifier hs-type">Storable</span></a></span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#Bool"><span class="hs-identifier hs-type">Bool</span></a></span></span></span></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-159"></span><span>   </span><span id="local-6989586621679508073"><span class="annot"><span class="annottext">sizeOf :: Bool -&gt; Int
</span><a href="#local-6989586621679508073"><span class="hs-identifier hs-var hs-var hs-var hs-var">sizeOf</span></a></span></span><span> </span><span class="annot"><span class="annottext">Bool
</span><span class="hs-identifier">_</span></span><span>          </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Int32 -&gt; Int
forall a. Storable a =&gt; a -&gt; Int
</span><a href="Foreign.Storable.html#sizeOf"><span class="hs-identifier hs-var">sizeOf</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int32
forall a. HasCallStack =&gt; a
</span><a href="GHC.Err.html#undefined"><span class="hs-identifier hs-var">undefined</span></a></span><span class="hs-glyph">::</span><span class="hs-identifier">HTYPE_INT</span><span class="hs-special">)</span><span>
</span><span id="line-160"></span><span>   </span><span id="local-6989586621679508069"><span class="annot"><span class="annottext">alignment :: Bool -&gt; Int
</span><a href="#local-6989586621679508069"><span class="hs-identifier hs-var hs-var hs-var hs-var">alignment</span></a></span></span><span> </span><span class="annot"><span class="annottext">Bool
</span><span class="hs-identifier">_</span></span><span>       </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Int32 -&gt; Int
forall a. Storable a =&gt; a -&gt; Int
</span><a href="Foreign.Storable.html#alignment"><span class="hs-identifier hs-var">alignment</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int32
forall a. HasCallStack =&gt; a
</span><a href="GHC.Err.html#undefined"><span class="hs-identifier hs-var">undefined</span></a></span><span class="hs-glyph">::</span><span class="hs-identifier">HTYPE_INT</span><span class="hs-special">)</span><span>
</span><span id="line-161"></span><span>   </span><span id="local-6989586621679508062"><span class="annot"><span class="annottext">peekElemOff :: Ptr Bool -&gt; Int -&gt; IO Bool
</span><a href="#local-6989586621679508062"><span class="hs-identifier hs-var hs-var hs-var hs-var">peekElemOff</span></a></span></span><span> </span><span id="local-6989586621679508061"><span class="annot"><span class="annottext">Ptr Bool
</span><a href="#local-6989586621679508061"><span class="hs-identifier hs-var">p</span></a></span></span><span> </span><span id="local-6989586621679508060"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679508060"><span class="hs-identifier hs-var">i</span></a></span></span><span>   </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Int32 -&gt; Bool) -&gt; IO Int32 -&gt; IO Bool
forall (m :: * -&gt; *) a1 r. Monad m =&gt; (a1 -&gt; r) -&gt; m a1 -&gt; m r
</span><a href="GHC.Base.html#liftM"><span class="hs-identifier hs-var">liftM</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int32 -&gt; Int32 -&gt; Bool
forall a. Eq a =&gt; a -&gt; a -&gt; Bool
</span><a href="../../ghc-prim/src/GHC.Classes.html#%2F%3D"><span class="hs-operator hs-var">/=</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int32
</span><span class="hs-number">0</span></span><span class="hs-glyph">::</span><span class="hs-identifier">HTYPE_INT</span><span class="hs-special">)</span><span class="hs-special">)</span><span> </span><span class="hs-operator">$</span><span> </span><span class="hs-identifier">peekElemOff</span><span> </span><span class="hs-special">(</span><span class="hs-identifier">castPtr</span><span> </span><span class="hs-identifier">p</span><span class="hs-special">)</span><span> </span><span class="hs-identifier">i</span><span>
</span><span id="line-162"></span><span>   </span><span id="local-6989586621679508053"><span class="annot"><span class="annottext">pokeElemOff :: Ptr Bool -&gt; Int -&gt; Bool -&gt; IO ()
</span><a href="#local-6989586621679508053"><span class="hs-identifier hs-var hs-var hs-var hs-var">pokeElemOff</span></a></span></span><span> </span><span id="local-6989586621679508052"><span class="annot"><span class="annottext">Ptr Bool
</span><a href="#local-6989586621679508052"><span class="hs-identifier hs-var">p</span></a></span></span><span> </span><span id="local-6989586621679508051"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679508051"><span class="hs-identifier hs-var">i</span></a></span></span><span> </span><span id="local-6989586621679508050"><span class="annot"><span class="annottext">Bool
</span><a href="#local-6989586621679508050"><span class="hs-identifier hs-var">x</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Ptr Int32 -&gt; Int -&gt; Int32 -&gt; IO ()
forall a. Storable a =&gt; Ptr a -&gt; Int -&gt; a -&gt; IO ()
</span><a href="Foreign.Storable.html#pokeElemOff"><span class="hs-identifier hs-var">pokeElemOff</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Ptr Bool -&gt; Ptr Int32
forall a b. Ptr a -&gt; Ptr b
</span><a href="GHC.Ptr.html#castPtr"><span class="hs-identifier hs-var">castPtr</span></a></span><span> </span><span class="annot"><span class="annottext">Ptr Bool
</span><a href="#local-6989586621679508052"><span class="hs-identifier hs-var">p</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679508051"><span class="hs-identifier hs-var">i</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-keyword">if</span><span> </span><span class="annot"><span class="annottext">Bool
</span><a href="#local-6989586621679508050"><span class="hs-identifier hs-var">x</span></a></span><span> </span><span class="hs-keyword">then</span><span> </span><span class="annot"><span class="annottext">Int32
</span><span class="hs-number">1</span></span><span> </span><span class="hs-keyword">else</span><span> </span><span class="annot"><span class="annottext">Int32
</span><span class="hs-number">0</span></span><span class="hs-glyph">::</span><span class="hs-identifier">HTYPE_INT</span><span class="hs-special">)</span><span class="hs-cpp">

#define STORABLE(T,size,align,read,write)       \
instance Storable (T) where {                   \
    sizeOf    _ = size;                         \
    alignment _ = align;                        \
    peekElemOff = read;                         \
    pokeElemOff = write }
</span><span>
</span><span id="line-171"></span><span class="hs-comment">-- | @since 2.01</span><span>
</span><span id="line-172"></span><span class="hs-identifier">STORABLE</span><span class="hs-special">(</span><span id="local-6989586621679508038"><span id="local-6989586621679508040"><span id="local-6989586621679508042"><span id="local-6989586621679508044"><span class="hs-identifier">Char</span><span class="hs-special">,</span></span></span></span></span><span class="hs-identifier">SIZEOF_INT32</span><span class="hs-special">,</span><span class="hs-identifier">ALIGNMENT_INT32</span><span class="hs-special">,</span><span>
</span><span id="line-173"></span><span>         </span><span class="hs-identifier">readWideCharOffPtr</span><span class="hs-special">,</span><span class="hs-identifier">writeWideCharOffPtr</span><span class="hs-special">)</span><span>
</span><span id="line-174"></span><span>
</span><span id="line-175"></span><span class="hs-comment">-- | @since 2.01</span><span>
</span><span id="line-176"></span><span class="hs-identifier">STORABLE</span><span class="hs-special">(</span><span id="local-6989586621679508020"><span id="local-6989586621679508022"><span id="local-6989586621679508024"><span id="local-6989586621679508026"><span class="hs-identifier">Int</span><span class="hs-special">,</span></span></span></span></span><span class="hs-identifier">SIZEOF_HSINT</span><span class="hs-special">,</span><span class="hs-identifier">ALIGNMENT_HSINT</span><span class="hs-special">,</span><span>
</span><span id="line-177"></span><span>         </span><span class="hs-identifier">readIntOffPtr</span><span class="hs-special">,</span><span class="hs-identifier">writeIntOffPtr</span><span class="hs-special">)</span><span>
</span><span id="line-178"></span><span>
</span><span id="line-179"></span><span class="hs-comment">-- | @since 2.01</span><span>
</span><span id="line-180"></span><span class="hs-identifier">STORABLE</span><span class="hs-special">(</span><span id="local-6989586621679508002"><span id="local-6989586621679508004"><span id="local-6989586621679508006"><span id="local-6989586621679508008"><span class="hs-identifier">Word</span><span class="hs-special">,</span></span></span></span></span><span class="hs-identifier">SIZEOF_HSWORD</span><span class="hs-special">,</span><span class="hs-identifier">ALIGNMENT_HSWORD</span><span class="hs-special">,</span><span>
</span><span id="line-181"></span><span>         </span><span class="hs-identifier">readWordOffPtr</span><span class="hs-special">,</span><span class="hs-identifier">writeWordOffPtr</span><span class="hs-special">)</span><span>
</span><span id="line-182"></span><span>
</span><span id="line-183"></span><span class="hs-comment">-- | @since 2.01</span><span>
</span><span id="line-184"></span><span id="local-6989586621679508297"><span class="hs-identifier">STORABLE</span><span class="hs-special">(</span><span id="local-6989586621679507984"><span id="local-6989586621679507986"><span id="local-6989586621679507988"><span id="local-6989586621679507990"><span class="hs-special">(</span><span class="hs-identifier">Ptr</span><span> </span><span class="hs-identifier">a</span><span class="hs-special">)</span><span class="hs-special">,</span></span></span></span></span><span class="hs-identifier">SIZEOF_HSPTR</span><span class="hs-special">,</span><span class="hs-identifier">ALIGNMENT_HSPTR</span><span class="hs-special">,</span></span><span>
</span><span id="line-185"></span><span>         </span><span class="hs-identifier">readPtrOffPtr</span><span class="hs-special">,</span><span class="hs-identifier">writePtrOffPtr</span><span class="hs-special">)</span><span>
</span><span id="line-186"></span><span>
</span><span id="line-187"></span><span class="hs-comment">-- | @since 2.01</span><span>
</span><span id="line-188"></span><span id="local-6989586621679508296"><span class="hs-identifier">STORABLE</span><span class="hs-special">(</span><span id="local-6989586621679507966"><span id="local-6989586621679507968"><span id="local-6989586621679507970"><span id="local-6989586621679507972"><span class="hs-special">(</span><span class="hs-identifier">FunPtr</span><span> </span><span class="hs-identifier">a</span><span class="hs-special">)</span><span class="hs-special">,</span></span></span></span></span><span class="hs-identifier">SIZEOF_HSFUNPTR</span><span class="hs-special">,</span><span class="hs-identifier">ALIGNMENT_HSFUNPTR</span><span class="hs-special">,</span></span><span>
</span><span id="line-189"></span><span>         </span><span class="hs-identifier">readFunPtrOffPtr</span><span class="hs-special">,</span><span class="hs-identifier">writeFunPtrOffPtr</span><span class="hs-special">)</span><span>
</span><span id="line-190"></span><span>
</span><span id="line-191"></span><span class="hs-comment">-- | @since 2.01</span><span>
</span><span id="line-192"></span><span id="local-6989586621679508295"><span class="hs-identifier">STORABLE</span><span class="hs-special">(</span><span id="local-6989586621679507948"><span id="local-6989586621679507950"><span id="local-6989586621679507952"><span id="local-6989586621679507954"><span class="hs-special">(</span><span class="hs-identifier">StablePtr</span><span> </span><span class="hs-identifier">a</span><span class="hs-special">)</span><span class="hs-special">,</span></span></span></span></span><span class="hs-identifier">SIZEOF_HSSTABLEPTR</span><span class="hs-special">,</span><span class="hs-identifier">ALIGNMENT_HSSTABLEPTR</span><span class="hs-special">,</span></span><span>
</span><span id="line-193"></span><span>         </span><span class="hs-identifier">readStablePtrOffPtr</span><span class="hs-special">,</span><span class="hs-identifier">writeStablePtrOffPtr</span><span class="hs-special">)</span><span>
</span><span id="line-194"></span><span>
</span><span id="line-195"></span><span class="hs-comment">-- | @since 2.01</span><span>
</span><span id="line-196"></span><span class="hs-identifier">STORABLE</span><span class="hs-special">(</span><span id="local-6989586621679507930"><span id="local-6989586621679507932"><span id="local-6989586621679507934"><span id="local-6989586621679507936"><span class="hs-identifier">Float</span><span class="hs-special">,</span></span></span></span></span><span class="hs-identifier">SIZEOF_HSFLOAT</span><span class="hs-special">,</span><span class="hs-identifier">ALIGNMENT_HSFLOAT</span><span class="hs-special">,</span><span>
</span><span id="line-197"></span><span>         </span><span class="hs-identifier">readFloatOffPtr</span><span class="hs-special">,</span><span class="hs-identifier">writeFloatOffPtr</span><span class="hs-special">)</span><span>
</span><span id="line-198"></span><span>
</span><span id="line-199"></span><span class="hs-comment">-- | @since 2.01</span><span>
</span><span id="line-200"></span><span class="hs-identifier">STORABLE</span><span class="hs-special">(</span><span id="local-6989586621679507912"><span id="local-6989586621679507914"><span id="local-6989586621679507916"><span id="local-6989586621679507918"><span class="hs-identifier">Double</span><span class="hs-special">,</span></span></span></span></span><span class="hs-identifier">SIZEOF_HSDOUBLE</span><span class="hs-special">,</span><span class="hs-identifier">ALIGNMENT_HSDOUBLE</span><span class="hs-special">,</span><span>
</span><span id="line-201"></span><span>         </span><span class="hs-identifier">readDoubleOffPtr</span><span class="hs-special">,</span><span class="hs-identifier">writeDoubleOffPtr</span><span class="hs-special">)</span><span>
</span><span id="line-202"></span><span>
</span><span id="line-203"></span><span class="hs-comment">-- | @since 2.01</span><span>
</span><span id="line-204"></span><span class="hs-identifier">STORABLE</span><span class="hs-special">(</span><span id="local-6989586621679507894"><span id="local-6989586621679507896"><span id="local-6989586621679507898"><span id="local-6989586621679507900"><span class="hs-identifier">Word8</span><span class="hs-special">,</span></span></span></span></span><span class="hs-identifier">SIZEOF_WORD8</span><span class="hs-special">,</span><span class="hs-identifier">ALIGNMENT_WORD8</span><span class="hs-special">,</span><span>
</span><span id="line-205"></span><span>         </span><span class="hs-identifier">readWord8OffPtr</span><span class="hs-special">,</span><span class="hs-identifier">writeWord8OffPtr</span><span class="hs-special">)</span><span>
</span><span id="line-206"></span><span>
</span><span id="line-207"></span><span class="hs-comment">-- | @since 2.01</span><span>
</span><span id="line-208"></span><span class="hs-identifier">STORABLE</span><span class="hs-special">(</span><span id="local-6989586621679507876"><span id="local-6989586621679507878"><span id="local-6989586621679507880"><span id="local-6989586621679507882"><span class="hs-identifier">Word16</span><span class="hs-special">,</span></span></span></span></span><span class="hs-identifier">SIZEOF_WORD16</span><span class="hs-special">,</span><span class="hs-identifier">ALIGNMENT_WORD16</span><span class="hs-special">,</span><span>
</span><span id="line-209"></span><span>         </span><span class="hs-identifier">readWord16OffPtr</span><span class="hs-special">,</span><span class="hs-identifier">writeWord16OffPtr</span><span class="hs-special">)</span><span>
</span><span id="line-210"></span><span>
</span><span id="line-211"></span><span class="hs-comment">-- | @since 2.01</span><span>
</span><span id="line-212"></span><span class="hs-identifier">STORABLE</span><span class="hs-special">(</span><span id="local-6989586621679507858"><span id="local-6989586621679507860"><span id="local-6989586621679507862"><span id="local-6989586621679507864"><span class="hs-identifier">Word32</span><span class="hs-special">,</span></span></span></span></span><span class="hs-identifier">SIZEOF_WORD32</span><span class="hs-special">,</span><span class="hs-identifier">ALIGNMENT_WORD32</span><span class="hs-special">,</span><span>
</span><span id="line-213"></span><span>         </span><span class="hs-identifier">readWord32OffPtr</span><span class="hs-special">,</span><span class="hs-identifier">writeWord32OffPtr</span><span class="hs-special">)</span><span>
</span><span id="line-214"></span><span>
</span><span id="line-215"></span><span class="hs-comment">-- | @since 2.01</span><span>
</span><span id="line-216"></span><span class="hs-identifier">STORABLE</span><span class="hs-special">(</span><span id="local-6989586621679507840"><span id="local-6989586621679507842"><span id="local-6989586621679507844"><span id="local-6989586621679507846"><span class="hs-identifier">Word64</span><span class="hs-special">,</span></span></span></span></span><span class="hs-identifier">SIZEOF_WORD64</span><span class="hs-special">,</span><span class="hs-identifier">ALIGNMENT_WORD64</span><span class="hs-special">,</span><span>
</span><span id="line-217"></span><span>         </span><span class="hs-identifier">readWord64OffPtr</span><span class="hs-special">,</span><span class="hs-identifier">writeWord64OffPtr</span><span class="hs-special">)</span><span>
</span><span id="line-218"></span><span>
</span><span id="line-219"></span><span class="hs-comment">-- | @since 2.01</span><span>
</span><span id="line-220"></span><span class="hs-identifier">STORABLE</span><span class="hs-special">(</span><span id="local-6989586621679507822"><span id="local-6989586621679507824"><span id="local-6989586621679507826"><span id="local-6989586621679507828"><span class="hs-identifier">Int8</span><span class="hs-special">,</span></span></span></span></span><span class="hs-identifier">SIZEOF_INT8</span><span class="hs-special">,</span><span class="hs-identifier">ALIGNMENT_INT8</span><span class="hs-special">,</span><span>
</span><span id="line-221"></span><span>         </span><span class="hs-identifier">readInt8OffPtr</span><span class="hs-special">,</span><span class="hs-identifier">writeInt8OffPtr</span><span class="hs-special">)</span><span>
</span><span id="line-222"></span><span>
</span><span id="line-223"></span><span class="hs-comment">-- | @since 2.01</span><span>
</span><span id="line-224"></span><span class="hs-identifier">STORABLE</span><span class="hs-special">(</span><span id="local-6989586621679507804"><span id="local-6989586621679507806"><span id="local-6989586621679507808"><span id="local-6989586621679507810"><span class="hs-identifier">Int16</span><span class="hs-special">,</span></span></span></span></span><span class="hs-identifier">SIZEOF_INT16</span><span class="hs-special">,</span><span class="hs-identifier">ALIGNMENT_INT16</span><span class="hs-special">,</span><span>
</span><span id="line-225"></span><span>         </span><span class="hs-identifier">readInt16OffPtr</span><span class="hs-special">,</span><span class="hs-identifier">writeInt16OffPtr</span><span class="hs-special">)</span><span>
</span><span id="line-226"></span><span>
</span><span id="line-227"></span><span class="hs-comment">-- | @since 2.01</span><span>
</span><span id="line-228"></span><span class="hs-identifier">STORABLE</span><span class="hs-special">(</span><span id="local-6989586621679507786"><span id="local-6989586621679507788"><span id="local-6989586621679507790"><span id="local-6989586621679507792"><span class="hs-identifier">Int32</span><span class="hs-special">,</span></span></span></span></span><span class="hs-identifier">SIZEOF_INT32</span><span class="hs-special">,</span><span class="hs-identifier">ALIGNMENT_INT32</span><span class="hs-special">,</span><span>
</span><span id="line-229"></span><span>         </span><span class="hs-identifier">readInt32OffPtr</span><span class="hs-special">,</span><span class="hs-identifier">writeInt32OffPtr</span><span class="hs-special">)</span><span>
</span><span id="line-230"></span><span>
</span><span id="line-231"></span><span class="hs-comment">-- | @since 2.01</span><span>
</span><span id="line-232"></span><span class="hs-identifier">STORABLE</span><span class="hs-special">(</span><span id="local-6989586621679507768"><span id="local-6989586621679507770"><span id="local-6989586621679507772"><span id="local-6989586621679507774"><span class="hs-identifier">Int64</span><span class="hs-special">,</span></span></span></span></span><span class="hs-identifier">SIZEOF_INT64</span><span class="hs-special">,</span><span class="hs-identifier">ALIGNMENT_INT64</span><span class="hs-special">,</span><span>
</span><span id="line-233"></span><span>         </span><span class="hs-identifier">readInt64OffPtr</span><span class="hs-special">,</span><span class="hs-identifier">writeInt64OffPtr</span><span class="hs-special">)</span><span>
</span><span id="line-234"></span><span>
</span><span id="line-235"></span><span class="hs-comment">-- | @since 4.8.0.0</span><span>
</span><span id="line-236"></span><span id="local-6989586621679508294"><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679507752"><span id="local-6989586621679507754"><span id="local-6989586621679507756"><span id="local-6989586621679507758"><span class="hs-special">(</span><span class="annot"><a href="Foreign.Storable.html#Storable"><span class="hs-identifier hs-type">Storable</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679508294"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Real.html#Integral"><span class="hs-identifier hs-type">Integral</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679508294"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Foreign.Storable.html#Storable"><span class="hs-identifier hs-type">Storable</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.Real.html#Ratio"><span class="hs-identifier hs-type">Ratio</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679508294"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span></span></span></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-237"></span><span>    </span><span id="local-6989586621679507744"><span class="annot"><span class="annottext">sizeOf :: Ratio a -&gt; Int
</span><a href="#local-6989586621679507744"><span class="hs-identifier hs-var hs-var hs-var hs-var">sizeOf</span></a></span></span><span> </span><span class="annot"><span class="annottext">Ratio a
</span><span class="hs-identifier">_</span></span><span>    </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">2</span></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Int
forall a. Num a =&gt; a -&gt; a -&gt; a
</span><a href="GHC.Num.html#%2A"><span class="hs-operator hs-var">*</span></a></span><span> </span><span class="annot"><span class="annottext">a -&gt; Int
forall a. Storable a =&gt; a -&gt; Int
</span><a href="Foreign.Storable.html#sizeOf"><span class="hs-identifier hs-var">sizeOf</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">a
forall a. HasCallStack =&gt; a
</span><a href="GHC.Err.html#undefined"><span class="hs-identifier hs-var">undefined</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="#local-6989586621679508294"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-238"></span><span>    </span><span id="local-6989586621679507740"><span class="annot"><span class="annottext">alignment :: Ratio a -&gt; Int
</span><a href="#local-6989586621679507740"><span class="hs-identifier hs-var hs-var hs-var hs-var">alignment</span></a></span></span><span> </span><span class="annot"><span class="annottext">Ratio a
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">a -&gt; Int
forall a. Storable a =&gt; a -&gt; Int
</span><a href="Foreign.Storable.html#alignment"><span class="hs-identifier hs-var">alignment</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">a
forall a. HasCallStack =&gt; a
</span><a href="GHC.Err.html#undefined"><span class="hs-identifier hs-var">undefined</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="#local-6989586621679508294"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-special">)</span><span>
</span><span id="line-239"></span><span>    </span><span id="local-6989586621679507731"><span class="annot"><span class="annottext">peek :: Ptr (Ratio a) -&gt; IO (Ratio a)
</span><a href="#local-6989586621679507731"><span class="hs-identifier hs-var hs-var hs-var hs-var">peek</span></a></span></span><span> </span><span id="local-6989586621679507730"><span class="annot"><span class="annottext">Ptr (Ratio a)
</span><a href="#local-6989586621679507730"><span class="hs-identifier hs-var">p</span></a></span></span><span>           </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-240"></span><span>                        </span><span id="local-6989586621679507729"><span class="annot"><span class="annottext">Ptr a
</span><a href="#local-6989586621679507729"><span class="hs-identifier hs-var">q</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Ptr a -&gt; IO (Ptr a)
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">(Ptr a -&gt; IO (Ptr a)) -&gt; Ptr a -&gt; IO (Ptr a)
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">Ptr (Ratio a) -&gt; Ptr a
forall a b. Ptr a -&gt; Ptr b
</span><a href="GHC.Ptr.html#castPtr"><span class="hs-identifier hs-var">castPtr</span></a></span><span> </span><span class="annot"><span class="annottext">Ptr (Ratio a)
</span><a href="#local-6989586621679507730"><span class="hs-identifier hs-var">p</span></a></span><span>
</span><span id="line-241"></span><span>                        </span><span id="local-6989586621679507728"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679507728"><span class="hs-identifier hs-var">r</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Ptr a -&gt; IO a
forall a. Storable a =&gt; Ptr a -&gt; IO a
</span><a href="Foreign.Storable.html#peek"><span class="hs-identifier hs-var">peek</span></a></span><span> </span><span class="annot"><span class="annottext">Ptr a
</span><a href="#local-6989586621679507729"><span class="hs-identifier hs-var">q</span></a></span><span>
</span><span id="line-242"></span><span>                        </span><span id="local-6989586621679507727"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679507727"><span class="hs-identifier hs-var">i</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Ptr a -&gt; Int -&gt; IO a
forall a. Storable a =&gt; Ptr a -&gt; Int -&gt; IO a
</span><a href="Foreign.Storable.html#peekElemOff"><span class="hs-identifier hs-var">peekElemOff</span></a></span><span> </span><span class="annot"><span class="annottext">Ptr a
</span><a href="#local-6989586621679507729"><span class="hs-identifier hs-var">q</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">1</span></span><span>
</span><span id="line-243"></span><span>                        </span><span class="annot"><span class="annottext">Ratio a -&gt; IO (Ratio a)
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679507728"><span class="hs-identifier hs-var">r</span></a></span><span> </span><span class="annot"><span class="annottext">a -&gt; a -&gt; Ratio a
forall a. Integral a =&gt; a -&gt; a -&gt; Ratio a
</span><a href="GHC.Real.html#%25"><span class="hs-operator hs-var">%</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679507727"><span class="hs-identifier hs-var">i</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-244"></span><span>    </span><span id="local-6989586621679507720"><span class="annot"><span class="annottext">poke :: Ptr (Ratio a) -&gt; Ratio a -&gt; IO ()
</span><a href="#local-6989586621679507720"><span class="hs-identifier hs-var hs-var hs-var hs-var">poke</span></a></span></span><span> </span><span id="local-6989586621679507719"><span class="annot"><span class="annottext">Ptr (Ratio a)
</span><a href="#local-6989586621679507719"><span class="hs-identifier hs-var">p</span></a></span></span><span> </span><span class="hs-special">(</span><span id="local-6989586621679507718"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679507718"><span class="hs-identifier hs-var">r</span></a></span></span><span> </span><span class="annot"><a href="GHC.Real.html#%3A%25"><span class="hs-operator hs-type">:%</span></a></span><span> </span><span id="local-6989586621679507717"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679507717"><span class="hs-identifier hs-var">i</span></a></span></span><span class="hs-special">)</span><span>  </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-245"></span><span>                        </span><span id="local-6989586621679507716"><span class="annot"><span class="annottext">Ptr a
</span><a href="#local-6989586621679507716"><span class="hs-identifier hs-var">q</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span class="annot"><span class="annottext">Ptr a -&gt; IO (Ptr a)
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">(Ptr a -&gt; IO (Ptr a)) -&gt; Ptr a -&gt; IO (Ptr a)
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span>  </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Ptr (Ratio a) -&gt; Ptr a
forall a b. Ptr a -&gt; Ptr b
</span><a href="GHC.Ptr.html#castPtr"><span class="hs-identifier hs-var">castPtr</span></a></span><span> </span><span class="annot"><span class="annottext">Ptr (Ratio a)
</span><a href="#local-6989586621679507719"><span class="hs-identifier hs-var">p</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-246"></span><span>                        </span><span class="annot"><span class="annottext">Ptr a -&gt; a -&gt; IO ()
forall a. Storable a =&gt; Ptr a -&gt; a -&gt; IO ()
</span><a href="Foreign.Storable.html#poke"><span class="hs-identifier hs-var">poke</span></a></span><span> </span><span class="annot"><span class="annottext">Ptr a
</span><a href="#local-6989586621679507716"><span class="hs-identifier hs-var">q</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679507718"><span class="hs-identifier hs-var">r</span></a></span><span>
</span><span id="line-247"></span><span>                        </span><span class="annot"><span class="annottext">Ptr a -&gt; Int -&gt; a -&gt; IO ()
forall a. Storable a =&gt; Ptr a -&gt; Int -&gt; a -&gt; IO ()
</span><a href="Foreign.Storable.html#pokeElemOff"><span class="hs-identifier hs-var">pokeElemOff</span></a></span><span> </span><span class="annot"><span class="annottext">Ptr a
</span><a href="#local-6989586621679507716"><span class="hs-identifier hs-var">q</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">1</span></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679507717"><span class="hs-identifier hs-var">i</span></a></span></span><span>
</span><span id="line-248"></span><span>
</span><span id="line-249"></span><span class="hs-comment">-- XXX: here to avoid orphan instance in GHC.Fingerprint</span><span>
</span><span id="line-250"></span><span class="hs-comment">-- | @since 4.4.0.0</span><span>
</span><span id="line-251"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679507706"><span id="local-6989586621679507708"><span id="local-6989586621679507710"><span id="local-6989586621679507712"><span class="annot"><a href="Foreign.Storable.html#Storable"><span class="hs-identifier hs-type">Storable</span></a></span><span> </span><span class="annot"><a href="GHC.Fingerprint.Type.html#Fingerprint"><span class="hs-identifier hs-type">Fingerprint</span></a></span></span></span></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-252"></span><span>  </span><span id="local-6989586621679507703"><span class="annot"><span class="annottext">sizeOf :: Fingerprint -&gt; Int
</span><a href="#local-6989586621679507703"><span class="hs-identifier hs-var hs-var hs-var hs-var">sizeOf</span></a></span></span><span> </span><span class="annot"><span class="annottext">Fingerprint
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">16</span></span><span>
</span><span id="line-253"></span><span>  </span><span id="local-6989586621679507702"><span class="annot"><span class="annottext">alignment :: Fingerprint -&gt; Int
</span><a href="#local-6989586621679507702"><span class="hs-identifier hs-var hs-var hs-var hs-var">alignment</span></a></span></span><span> </span><span class="annot"><span class="annottext">Fingerprint
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">8</span></span><span>
</span><span id="line-254"></span><span>  </span><span id="local-6989586621679507701"><span class="annot"><span class="annottext">peek :: Ptr Fingerprint -&gt; IO Fingerprint
</span><a href="#local-6989586621679507701"><span class="hs-identifier hs-var hs-var hs-var hs-var">peek</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Ptr Fingerprint -&gt; IO Fingerprint
</span><a href="Foreign.Storable.html#peekFingerprint"><span class="hs-identifier hs-var">peekFingerprint</span></a></span><span>
</span><span id="line-255"></span><span>  </span><span id="local-6989586621679507699"><span class="annot"><span class="annottext">poke :: Ptr Fingerprint -&gt; Fingerprint -&gt; IO ()
</span><a href="#local-6989586621679507699"><span class="hs-identifier hs-var hs-var hs-var hs-var">poke</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Ptr Fingerprint -&gt; Fingerprint -&gt; IO ()
</span><a href="Foreign.Storable.html#pokeFingerprint"><span class="hs-identifier hs-var">pokeFingerprint</span></a></span><span>
</span><span id="line-256"></span><span>
</span><span id="line-257"></span><span class="hs-comment">-- peek/poke in fixed BIG-endian 128-bit format</span><span>
</span><span id="line-258"></span><span class="annot"><a href="Foreign.Storable.html#peekFingerprint"><span class="hs-identifier hs-type">peekFingerprint</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.Ptr.html#Ptr"><span class="hs-identifier hs-type">Ptr</span></a></span><span> </span><span class="annot"><a href="GHC.Fingerprint.Type.html#Fingerprint"><span class="hs-identifier hs-type">Fingerprint</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#IO"><span class="hs-identifier hs-type">IO</span></a></span><span> </span><span class="annot"><a href="GHC.Fingerprint.Type.html#Fingerprint"><span class="hs-identifier hs-type">Fingerprint</span></a></span><span>
</span><span id="line-259"></span><span id="peekFingerprint"><span class="annot"><span class="annottext">peekFingerprint :: Ptr Fingerprint -&gt; IO Fingerprint
</span><a href="Foreign.Storable.html#peekFingerprint"><span class="hs-identifier hs-var hs-var">peekFingerprint</span></a></span></span><span> </span><span id="local-6989586621679507697"><span class="annot"><span class="annottext">Ptr Fingerprint
</span><a href="#local-6989586621679507697"><span class="hs-identifier hs-var">p0</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-260"></span><span>      </span><span class="hs-keyword">let</span><span> </span><span class="annot"><a href="#local-6989586621679507696"><span class="hs-identifier hs-type">peekW64</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.Ptr.html#Ptr"><span class="hs-identifier hs-type">Ptr</span></a></span><span> </span><span class="annot"><a href="GHC.Word.html#Word8"><span class="hs-identifier hs-type">Word8</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#Int"><span class="hs-identifier hs-type">Int</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Word.html#Word64"><span class="hs-identifier hs-type">Word64</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#IO"><span class="hs-identifier hs-type">IO</span></a></span><span> </span><span class="annot"><a href="GHC.Word.html#Word64"><span class="hs-identifier hs-type">Word64</span></a></span><span>
</span><span id="line-261"></span><span>          </span><span id="local-6989586621679507696"><span class="annot"><span class="annottext">peekW64 :: Ptr Word8 -&gt; Int -&gt; Word64 -&gt; IO Word64
</span><a href="#local-6989586621679507696"><span class="hs-identifier hs-var hs-var">peekW64</span></a></span></span><span> </span><span class="annot"><span class="annottext">Ptr Word8
</span><span class="hs-identifier">_</span></span><span>  </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">0</span></span><span>  </span><span class="hs-glyph">!</span><span id="local-6989586621679507695"><span class="annot"><span class="annottext">Word64
</span><a href="#local-6989586621679507695"><span class="hs-identifier hs-var">i</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Word64 -&gt; IO Word64
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">Word64
</span><a href="#local-6989586621679507695"><span class="hs-identifier hs-var">i</span></a></span><span>
</span><span id="line-262"></span><span>          </span><span class="annot"><a href="#local-6989586621679507696"><span class="hs-identifier hs-var">peekW64</span></a></span><span> </span><span class="hs-glyph">!</span><span id="local-6989586621679507694"><span class="annot"><span class="annottext">Ptr Word8
</span><a href="#local-6989586621679507694"><span class="hs-identifier hs-var">p</span></a></span></span><span> </span><span class="hs-glyph">!</span><span id="local-6989586621679507693"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679507693"><span class="hs-identifier hs-var">n</span></a></span></span><span> </span><span class="hs-glyph">!</span><span id="local-6989586621679507692"><span class="annot"><span class="annottext">Word64
</span><a href="#local-6989586621679507692"><span class="hs-identifier hs-var">i</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-263"></span><span>                </span><span id="local-6989586621679507691"><span class="annot"><span class="annottext">Word8
</span><a href="#local-6989586621679507691"><span class="hs-identifier hs-var">w8</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Ptr Word8 -&gt; IO Word8
forall a. Storable a =&gt; Ptr a -&gt; IO a
</span><a href="Foreign.Storable.html#peek"><span class="hs-identifier hs-var">peek</span></a></span><span> </span><span class="annot"><span class="annottext">Ptr Word8
</span><a href="#local-6989586621679507694"><span class="hs-identifier hs-var">p</span></a></span><span>
</span><span id="line-264"></span><span>                </span><span class="annot"><span class="annottext">Ptr Word8 -&gt; Int -&gt; Word64 -&gt; IO Word64
</span><a href="#local-6989586621679507696"><span class="hs-identifier hs-var">peekW64</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Ptr Word8
</span><a href="#local-6989586621679507694"><span class="hs-identifier hs-var">p</span></a></span><span> </span><span class="annot"><span class="annottext">Ptr Word8 -&gt; Int -&gt; Ptr Word8
forall a b. Ptr a -&gt; Int -&gt; Ptr b
</span><a href="GHC.Ptr.html#plusPtr"><span class="hs-operator hs-var">`plusPtr`</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">1</span></span><span class="hs-special">)</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679507693"><span class="hs-identifier hs-var">n</span></a></span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Int
forall a. Num a =&gt; a -&gt; a -&gt; a
</span><a href="GHC.Num.html#-"><span class="hs-glyph hs-var">-</span></a></span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">1</span></span><span class="hs-special">)</span><span> </span><span>
</span><span id="line-265"></span><span>                    </span><span class="hs-special">(</span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word64
</span><a href="#local-6989586621679507692"><span class="hs-identifier hs-var">i</span></a></span><span> </span><span class="annot"><span class="annottext">Word64 -&gt; Int -&gt; Word64
forall a. Bits a =&gt; a -&gt; Int -&gt; a
</span><a href="Data.Bits.html#shiftL"><span class="hs-operator hs-var">`shiftL`</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">8</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Word64 -&gt; Word64 -&gt; Word64
forall a. Bits a =&gt; a -&gt; a -&gt; a
</span><a href="Data.Bits.html#.%7C."><span class="hs-operator hs-var">.|.</span></a></span><span> </span><span class="annot"><span class="annottext">Word8 -&gt; Word64
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><a href="#local-6989586621679507691"><span class="hs-identifier hs-var">w8</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-266"></span><span>
</span><span id="line-267"></span><span>      </span><span id="local-6989586621679507688"><span class="annot"><span class="annottext">Word64
</span><a href="#local-6989586621679507688"><span class="hs-identifier hs-var">high</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Ptr Word8 -&gt; Int -&gt; Word64 -&gt; IO Word64
</span><a href="#local-6989586621679507696"><span class="hs-identifier hs-var">peekW64</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Ptr Fingerprint -&gt; Ptr Word8
forall a b. Ptr a -&gt; Ptr b
</span><a href="GHC.Ptr.html#castPtr"><span class="hs-identifier hs-var">castPtr</span></a></span><span> </span><span class="annot"><span class="annottext">Ptr Fingerprint
</span><a href="#local-6989586621679507697"><span class="hs-identifier hs-var">p0</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">8</span></span><span> </span><span class="annot"><span class="annottext">Word64
</span><span class="hs-number">0</span></span><span>
</span><span id="line-268"></span><span>      </span><span id="local-6989586621679507687"><span class="annot"><span class="annottext">Word64
</span><a href="#local-6989586621679507687"><span class="hs-identifier hs-var">low</span></a></span></span><span>  </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Ptr Word8 -&gt; Int -&gt; Word64 -&gt; IO Word64
</span><a href="#local-6989586621679507696"><span class="hs-identifier hs-var">peekW64</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Ptr Fingerprint -&gt; Ptr Any
forall a b. Ptr a -&gt; Ptr b
</span><a href="GHC.Ptr.html#castPtr"><span class="hs-identifier hs-var">castPtr</span></a></span><span> </span><span class="annot"><span class="annottext">Ptr Fingerprint
</span><a href="#local-6989586621679507697"><span class="hs-identifier hs-var">p0</span></a></span><span> </span><span class="annot"><span class="annottext">Ptr Any -&gt; Int -&gt; Ptr Word8
forall a b. Ptr a -&gt; Int -&gt; Ptr b
</span><a href="GHC.Ptr.html#plusPtr"><span class="hs-operator hs-var">`plusPtr`</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">8</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">8</span></span><span> </span><span class="annot"><span class="annottext">Word64
</span><span class="hs-number">0</span></span><span>
</span><span id="line-269"></span><span>      </span><span class="annot"><span class="annottext">Fingerprint -&gt; IO Fingerprint
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word64 -&gt; Word64 -&gt; Fingerprint
</span><a href="GHC.Fingerprint.Type.html#Fingerprint"><span class="hs-identifier hs-var">Fingerprint</span></a></span><span> </span><span class="annot"><span class="annottext">Word64
</span><a href="#local-6989586621679507688"><span class="hs-identifier hs-var">high</span></a></span><span> </span><span class="annot"><span class="annottext">Word64
</span><a href="#local-6989586621679507687"><span class="hs-identifier hs-var">low</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-270"></span><span>
</span><span id="line-271"></span><span class="annot"><a href="Foreign.Storable.html#pokeFingerprint"><span class="hs-identifier hs-type">pokeFingerprint</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.Ptr.html#Ptr"><span class="hs-identifier hs-type">Ptr</span></a></span><span> </span><span class="annot"><a href="GHC.Fingerprint.Type.html#Fingerprint"><span class="hs-identifier hs-type">Fingerprint</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Fingerprint.Type.html#Fingerprint"><span class="hs-identifier hs-type">Fingerprint</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#IO"><span class="hs-identifier hs-type">IO</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span><span>
</span><span id="line-272"></span><span id="pokeFingerprint"><span class="annot"><span class="annottext">pokeFingerprint :: Ptr Fingerprint -&gt; Fingerprint -&gt; IO ()
</span><a href="Foreign.Storable.html#pokeFingerprint"><span class="hs-identifier hs-var hs-var">pokeFingerprint</span></a></span></span><span> </span><span id="local-6989586621679507686"><span class="annot"><span class="annottext">Ptr Fingerprint
</span><a href="#local-6989586621679507686"><span class="hs-identifier hs-var">p0</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.Fingerprint.Type.html#Fingerprint"><span class="hs-identifier hs-type">Fingerprint</span></a></span><span> </span><span id="local-6989586621679507685"><span class="annot"><span class="annottext">Word64
</span><a href="#local-6989586621679507685"><span class="hs-identifier hs-var">high</span></a></span></span><span> </span><span id="local-6989586621679507684"><span class="annot"><span class="annottext">Word64
</span><a href="#local-6989586621679507684"><span class="hs-identifier hs-var">low</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-273"></span><span>      </span><span class="hs-keyword">let</span><span> </span><span class="annot"><a href="#local-6989586621679507683"><span class="hs-identifier hs-type">pokeW64</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.Ptr.html#Ptr"><span class="hs-identifier hs-type">Ptr</span></a></span><span> </span><span class="annot"><a href="GHC.Word.html#Word8"><span class="hs-identifier hs-type">Word8</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#Int"><span class="hs-identifier hs-type">Int</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Word.html#Word64"><span class="hs-identifier hs-type">Word64</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#IO"><span class="hs-identifier hs-type">IO</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span><span>
</span><span id="line-274"></span><span>          </span><span id="local-6989586621679507683"><span class="annot"><span class="annottext">pokeW64 :: Ptr Word8 -&gt; Int -&gt; Word64 -&gt; IO ()
</span><a href="#local-6989586621679507683"><span class="hs-identifier hs-var hs-var">pokeW64</span></a></span></span><span> </span><span class="annot"><span class="annottext">Ptr Word8
</span><span class="hs-identifier">_</span></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">0</span></span><span>  </span><span class="annot"><span class="annottext">Word64
</span><span class="hs-identifier">_</span></span><span>  </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">() -&gt; IO ()
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span><span>
</span><span id="line-275"></span><span>          </span><span class="annot"><a href="#local-6989586621679507683"><span class="hs-identifier hs-var">pokeW64</span></a></span><span> </span><span id="local-6989586621679507682"><span class="annot"><span class="annottext">Ptr Word8
</span><a href="#local-6989586621679507682"><span class="hs-identifier hs-var">p</span></a></span></span><span> </span><span class="hs-glyph">!</span><span id="local-6989586621679507681"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679507681"><span class="hs-identifier hs-var">n</span></a></span></span><span> </span><span class="hs-glyph">!</span><span id="local-6989586621679507680"><span class="annot"><span class="annottext">Word64
</span><a href="#local-6989586621679507680"><span class="hs-identifier hs-var">i</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-276"></span><span>                </span><span class="annot"><span class="annottext">Ptr Word8 -&gt; Int -&gt; Word8 -&gt; IO ()
forall a. Storable a =&gt; Ptr a -&gt; Int -&gt; a -&gt; IO ()
</span><a href="Foreign.Storable.html#pokeElemOff"><span class="hs-identifier hs-var">pokeElemOff</span></a></span><span> </span><span class="annot"><span class="annottext">Ptr Word8
</span><a href="#local-6989586621679507682"><span class="hs-identifier hs-var">p</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679507681"><span class="hs-identifier hs-var">n</span></a></span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Int
forall a. Num a =&gt; a -&gt; a -&gt; a
</span><a href="GHC.Num.html#-"><span class="hs-glyph hs-var">-</span></a></span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">1</span></span><span class="hs-special">)</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word64 -&gt; Word8
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="annot"><span class="annottext">Word64
</span><a href="#local-6989586621679507680"><span class="hs-identifier hs-var">i</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-277"></span><span>                </span><span class="annot"><span class="annottext">Ptr Word8 -&gt; Int -&gt; Word64 -&gt; IO ()
</span><a href="#local-6989586621679507683"><span class="hs-identifier hs-var">pokeW64</span></a></span><span> </span><span class="annot"><span class="annottext">Ptr Word8
</span><a href="#local-6989586621679507682"><span class="hs-identifier hs-var">p</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679507681"><span class="hs-identifier hs-var">n</span></a></span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Int
forall a. Num a =&gt; a -&gt; a -&gt; a
</span><a href="GHC.Num.html#-"><span class="hs-glyph hs-var">-</span></a></span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">1</span></span><span class="hs-special">)</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word64
</span><a href="#local-6989586621679507680"><span class="hs-identifier hs-var">i</span></a></span><span> </span><span class="annot"><span class="annottext">Word64 -&gt; Int -&gt; Word64
forall a. Bits a =&gt; a -&gt; Int -&gt; a
</span><a href="Data.Bits.html#shiftR"><span class="hs-operator hs-var">`shiftR`</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">8</span></span><span class="hs-special">)</span><span>
</span><span id="line-278"></span><span>
</span><span id="line-279"></span><span>      </span><span class="annot"><span class="annottext">Ptr Word8 -&gt; Int -&gt; Word64 -&gt; IO ()
</span><a href="#local-6989586621679507683"><span class="hs-identifier hs-var">pokeW64</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Ptr Fingerprint -&gt; Ptr Word8
forall a b. Ptr a -&gt; Ptr b
</span><a href="GHC.Ptr.html#castPtr"><span class="hs-identifier hs-var">castPtr</span></a></span><span> </span><span class="annot"><span class="annottext">Ptr Fingerprint
</span><a href="#local-6989586621679507686"><span class="hs-identifier hs-var">p0</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">8</span></span><span> </span><span class="annot"><span class="annottext">Word64
</span><a href="#local-6989586621679507685"><span class="hs-identifier hs-var">high</span></a></span><span>
</span><span id="line-280"></span><span>      </span><span class="annot"><span class="annottext">Ptr Word8 -&gt; Int -&gt; Word64 -&gt; IO ()
</span><a href="#local-6989586621679507683"><span class="hs-identifier hs-var">pokeW64</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Ptr Fingerprint -&gt; Ptr Any
forall a b. Ptr a -&gt; Ptr b
</span><a href="GHC.Ptr.html#castPtr"><span class="hs-identifier hs-var">castPtr</span></a></span><span> </span><span class="annot"><span class="annottext">Ptr Fingerprint
</span><a href="#local-6989586621679507686"><span class="hs-identifier hs-var">p0</span></a></span><span> </span><span class="annot"><span class="annottext">Ptr Any -&gt; Int -&gt; Ptr Word8
forall a b. Ptr a -&gt; Int -&gt; Ptr b
</span><a href="GHC.Ptr.html#plusPtr"><span class="hs-operator hs-var">`plusPtr`</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">8</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">8</span></span><span> </span><span class="annot"><span class="annottext">Word64
</span><a href="#local-6989586621679507684"><span class="hs-identifier hs-var">low</span></a></span><span>
</span><span id="line-281"></span></pre></body></html>